\section{\'Elaboration du projet}

\subsection{Création \& Configuration de réseaux Wi-Fi Arduino}

Les \textit{shields} Wi-Fi fournis permettent la création et la connexion de réseau Wi-Fi en mode infrastructure et ad hoc. Initialement, le projet devait se baser sur une communication dans ce dernier mode. L'écriture des programmes associés n'a pas posé de problèmes particuliers, avec en exemple le code pour la création d'un tel réseau : \\

\shadowbox{
\begin{lstlisting}[breaklines=true, breakatwhitespace=true]
void create_adhoc(char * ssid, int chanel) {
  Serial.begin(9600);
  SpiSerial.print("$$$"); //Passage en mode commande
  delay(800);
  SpiSerial.println("set wlan join 4"); //Configuration du mode Wi-Fi en adhoc
  delay(800);
  SpiSerial.print("set wlan ssid "); //Configuration du ssid
  SpiSerial.println(ssid);
  delay(800);
  SpiSerial.print("set wlan chan "); //Configuration du chanel
  SpiSerial.println(chanel);
  delay(800);
  SpiSerial.println("set ip dhcp 2"); //Activation du DHCP
  delay(800);
  SpiSerial.println("save"); //Sauvegarde de la configuration
  delay(800);
  SpiSerial.println("reboot"); //Rebooting...
  delay(3000);
  Serial.println("");
}
\end{lstlisting}}
\newline

Les tests effectués ont permis de faire des échanges de données entre deux modules Arduino avec succès. \\


\textbf{\normalsize{Problèmes rencontrés}}
\newline

Très rapidement, un problème majeur est apparu : il s'est révélé très difficile de connecter les tablettes Android que nous avions à un réseau Wi-Fi. En effet, le système d'exploitation Android ne gère nativement que les réseaux sans-fils en mode infrastructure, et nous n'avons finalement réussis à avancer qu'une fois en possession d'un routeur capable de connecter les modules Arduino et les tablettes. \\

Une solution alternative aurait pu être trouvée en partant sur la modification directe du système d'exploitation Android. Des tutoriaux sont disponibles sur Internet, mais cela aurait requis de remplacer des modules officiels par d'autres fournis par des services non-officiels et aurait de plus requis un piratage de la tablette pour nous attribuer les droits \textit{root}. Nous avons donc préférés nous débrouiller d'une autre manière. De plus, si nous avions fait ça, nous n'aurions peut-être pas eu le temps de s'investir d'avantage sur les autres \textit{shields}, de par la complexité de leurs problèmes individuels et le temps mis pour les régler.\\

\subsection{Protocole de communication}
Un protocole texte a été établi pour communiquer entre la tablette et les modules. Les requêtes envoyées par la tablette restent simples, puisqu'elles consistent à envoyer le caractère $\sharp$ suivit par un chiffre, chaque chiffre correspondant à une commande particulière. L'utilisation de ce format est justifié car le caractère $\sharp$ est rarement employé dans la vie courante (il n'y a donc pas de risques d'interférences), et surtout car la carte Arduino n'est capable de lire les flux entrant qu'octet par octet. L'utilisation de seulement 2 octets pour décrire une requête évite que le code ne devienne trop complexe et instable. \\

La réponse donnée par la carte Arduino est une chaine de caractères préfixée de 3 caractères indiquant la nature du module qui répond à la requête (\textit{"GPS"} pour le module GPS, \textit{"THM"} pour le module de température, etc...). Le reste de la chaine contient les données produites par le \textit{shield} (par exemple les coordonnées GPS dans le cas d'une requête Arduino/GPS). \\

En fonction du moyen de communication utilisé (réseau Wi-Fi ou GSM), nous utilisons pour communiquer une socket TCP classique dans le premier cas, et un envoi de SMS standard dans le deuxième cas.

\begin{center}
\begin{tabular}{|c|c|}
\hline
\multicolumn{2}{|c|}{Interrogation des modules}\\
\hline
\#1 & Demande des coordonnées GPS\\
\#2 & Demande de la température\\
\#3 & Demande de l'état de la porte\\
\#4 & Demande de la luminosité\\
\#? & Demande de la liste des services installés (Wi-Fi)\\
\hline
\hline
\multicolumn{2}{|c|}{Préfixes des réponses des modules}\\
\hline
GPS & Réponse du GPS\\
THM & Réponse de la sonde de température\\
DOO & Réponse du la sonde de la porte\\
LUM & Réponse du la sonde de luminosité\\
OK & Liste les services (Wi-Fi uniquement)\\
\hline
\end{tabular}
\end{center}

\subsection{Module tracker GPS}

Le module de tracking GPS consiste en l'association d'une alimentation externe, du \textit{shield} GPS, et d'un \textit{shield} de communication (Wi-Fi ou GSM). Il permet, grâce à l'utilisation du protocole de communication sus-cité, de donner sa géolocalisation sur simple demande. Lors de la réception de la chaîne $\sharp1$, le module met à jour ses coordonnées et les envoie à l'émetteur de la demande. \\

\begin{figure}[!h]
\centering
\includegraphics[scale=0.7]{assemblage_tracker_gps2.jpg}
\caption{Assemblage du module de tracker GPS}\label{fig:somefiglabel}
\end{figure}

L'utilisation de l'alimentation externe permet une entière autonomie du module, et il peut être utilisé n'importe où - du moment qu'un accès au réseau GSM est possible, car le \textit{shield} Wi-Fi aura rarement une portée suffisante pour être pertinent. \\

Le code suivant consiste à analyser les SMS entrants, puis à mettre à jour les coordonnées GPS pour les envoyer. \\

\shadowbox{
\begin{lstlisting}[breaklines=true, breakatwhitespace=true]
void loop(){
  if(Serial.available() > 0){
    parse_receiver(); //Permet de stocker le numero de l'emetteur du SMS entrant
    inchar = Serial.read();
    if (inchar == '#')
    {
      inchar = Serial.read();
      if (inchar=='1'){ //Si on recoit la chaine "#1"
        refresh_coor();
        send_sms_coor();
}}}}
\end{lstlisting}}

\subsection{Module d'information de luminosité}

Ce module permet de renseigner la luminosité auquel il est exposé. Nous utilisons pour cela un \textit{photoresistor} avec lequel nous calculons, grâce à sa résistance en sortie, le pourcentage de lumière associé. \\

\begin{figure}[!h]
\centering
\includegraphics[scale=75]{lumi.png}
\caption{Branchement du module de luminosité}\label{fig:somefiglabel}
\end{figure}

Le code associé ouvre une socket en mode serveur, puis attends qu'un client s'y connecte et y envoie la suite de caractères $\sharp4$. Lorsque cette chaîne est reçue, il écrit dans la socket l'information de luminosité après en avoir lu et calculé la valeur. Le code ci-dessous est un abrégé de la version Wi-Fi. \\

\shadowbox{
\begin{lstlisting}[breaklines=true, breakatwhitespace=true]
void loop() {
  Client client = server.available();
  if (client) {
    if (client.connected()) {
      while(client.available() < 1);
      char c1 = client.read();
      while(client.available() < 1);
      char c2 = client.read();
      if(c1=='#' && c2=='5'){
        getLumi(photo);
        client.println("Luminosite : ");
        client.println(lumi);
        client.println("%");
      }
      client.stop();
}}}
\end{lstlisting}}

\subsection{Module d'information de température}

Ce module permet de renseigner la température ambiante en degrés Celsius. Nous utilisons pour cela une \textit{thermorésistance} avec laquelle nous calculons la température associée. \\

\begin{figure}[!h]
\centering
\includegraphics[scale=72]{module_thermo.png}
\caption{Module d'information de température}\label{fig:somefiglabel}
\end{figure}

\newpage
Le code associé est très proche de celui du module de luminosité, à l'exception du calcul de la température :\\

\shadowbox{
\begin{lstlisting}[breaklines=true, breakatwhitespace=true]
[...]
client.println("Temp : ");
client.println((getVoltage(tmpin) - 0.5) * 100);
client.println("deg C");
[...]
\end{lstlisting}}

\subsection{Module de détection d'ouverture de porte}

Ce module permet de renseigner l'état d'une porte (sur laquelle il est branché) pour savoir si celle-ci est ouverte ou fermée. Nous utilisons un \textit{flex sensor} capable de détecter les torsions. En appliquant le \textit{sensor} sur le coin de la porte (voir figure 12), l'ouverture de celle-ci va engendrer une torsion du module que l'on est capable de détecter avec la carte Arduino. \\

\begin{figure}[!h]
\centering
\includegraphics[scale=0.8]{detecteur_porte.jpg}
\caption{Module du détecteur d'ouverture de porte}\label{fig:somefiglabel}
\end{figure}

Le code associé ne diffère que très peu des autres modules, la seule différence consistant en la lecture de la valeur du \textit{flex sensor}. Le code ci-dessous est celui de la version SMS.\\

\shadowbox{
\begin{lstlisting}[breaklines=true, breakatwhitespace=true]
void loop(){
  if(Serial.available() > 0){
    parse_receiver();
    inchar = Serial.read();
    if (inchar == '#'){
      inchar = Serial.read();
      if (inchar=='3'){ //Si on recoit la chaine "#3" (exemple de commande)
        int val = analogRead(flex);
        if(val >= 276) send_sms(1); //276 etant la valeur mediane du
 flex sensor
        else send_sms(0);
      }
    }
  }	
}
\end{lstlisting}}

\subimport{}{awacs}
